/*pmw_公共方法文件*/

import {Message} from 'element-ui';

/************************DOM区域***************************/

/*正则判断区域*/
const CheckRule = {
    /*修正+提示：账户信息输入框*/
    accountInputMatch(value) {//参数：input值
        if (!(/^[0-9]*$/).test(value)) {
            Message({
                type: 'warning',
                dangerouslyUseHTMLString: true,//允许html编辑
                message: '<b>用户账号</b>：请输入数字！',
                center: true
            })
        }
        return (parseInt(value) || '').toString()
    },//返回：String（数字 || ''）
    /*修正+提示：邮箱输入框*/
    emailInputMatch(value) {//参数：input值
        if (value === '') return value;
        if (!(/^([A-Za-z0-9_+-])+@([A-Za-z0-9\-])+\.([A-Za-z]{2,22})$/).test(value)) {
            Message({
                type: 'warning',
                dangerouslyUseHTMLString: true,//允许html编辑
                message: `<div style="text-align: center"><b>用户邮箱</b>：邮箱格式有误！</div><div style="text-align: center"><b>例</b>：example@example.example</div>`,
                center: true
            });
            return ''
        }
        return value
    },//返回：String（邮箱 || ''）
    /*修正+提示：用户手机输入框*/
    telInputMatch(value) {//参数：input值
        if (value === '') return value;
        if (!(/^1[3|4|5|7|8][0-9]{9}$/).test(value)) {
            Message({
                type: 'warning',
                dangerouslyUseHTMLString: true,//允许html编辑
                message: '<b>用户手机</b>：手机号码格式有误！',
                center: true
            });
            return ''
        }
        return value
    },//返回：String（邮箱 || ''）
};
/*弹框区域*/
const OpenBox = {
    boxClose(_this, done, typeString = '') {
        _this.$confirm(`确认取消${typeString}？`, '提示：', {
            type: "warning"
        })
            .then(_ => {
                if (_this.$data.dialogFormState) _this.$data.dialogFormState = '';//此行代码，仅针对role_manager.vue页面
                done();
            })
            .catch(_ => {
            });
    },
};
/*提示区域*/
const Notice = {
    canNotBeNull(value, typeMessage = '该选项') {
        if (value === '' || value.length === 0) {
            let tagType = '输入框';
            if (typeMessage === '该选项') tagType = '对应部分';
            else if (typeMessage === '角色' || typeMessage === '角色权限') tagType = '选择框';
            Message({
                type: 'warning',
                dangerouslyUseHTMLString: true,//允许html编辑
                message: `<b>${typeMessage}</b>的${tagType}不能为空！`,
                center: true
            })
        }
        return false
    },
    /*判断传入的所有内容是否为空*//**都不为空返回True，否则返回False**/
    bothNotBeNull(obj) {
        let arr = [];
        for (let keys in obj) {
            if (obj[keys] === null || obj[keys] === undefined) continue;
            if (obj[keys] === '' || obj[keys].length === 0) {
                switch (keys) {
                    case 'backUserName':
                        arr.push('账号');
                        break;
                    case 'backUserEmail':
                        arr.push('邮箱');
                        break;
                    case 'backUserTel':
                        arr.push('手机');
                        break;
                    case 'backUserPassword':
                        arr.push('密码');
                        break;
                    case 'backUserStatus':
                        arr.push('状态');
                        break;
                    case 'roleId':
                        arr.push('角色');
                        break;
                    case 'roleName':
                        arr.push('角色名称');
                        break;
                    case 'roleDesc':
                        arr.push('角色描述');
                        break;
                    case 'roleStatus':
                        arr.push('角色状态');
                        break;
                    case 'authName':
                        arr.push('角色权限');
                        break;
                }
            }
        }
        if (arr.length > 0) {
            Message({
                type: 'warning',
                dangerouslyUseHTMLString: true,//允许html编辑
                message: `以下内容，不能为空：<b>${arr}</b>`,
                center: true
            });
            return false
        } else {
            return true
        }

    },
    /*Message提示功能*//**参数说明：提示类型（noticeType），提示内容（noticeText）**/
    messageNotic(noticeText, noticeType = 'info') {
        let msg = '';
        switch (noticeType) {
            case 'success':
                msg = '成功';
                break;
            case 'warning':
                msg = '警告';
                break;
            case 'error':
                msg = '错误';
                break;
            case 'info':
                msg = '';
                break;
            default:
                return false;
        }
        Message({
            type: noticeType,
            dangerouslyUseHTMLString: true,//允许html编辑
            message: `<b>${noticeText}</b>${msg}`,
            center: true
        });
    }
};
/*操作区域*/
const Deal = {
    resetBtn(vueData) {
        for (let keys in vueData) {
            vueData[keys] = ''
        }
    },
};

/************************JS逻辑区域***************************/
const dealData = {
    /*根据传入的页数和页面数据大小，得到对应数据下标，再截取传入的数组里面的数据，并返回*/
    currentPageData(currentPage, pageSize, totalData) {
        let needData = [...totalData];
        let startMark = (parseInt(currentPage) - 1) * parseInt(pageSize);
        let endMark = parseInt(currentPage) * parseInt(pageSize);
        return needData.slice(startMark, endMark);
    },
    /*根据传入的对象，遍历传入的数组，返回对应的数据*/
    matchArrayData(searchData, searchObj, finalData = {isNotInput: true, data: []}) {
        /*参数类型判断*/
        if (!(Array.isArray(searchData))) return [];
        if (!(searchObj instanceof Object)) return [];

        /*清理传入的条件对象（由逻辑可知，只会在第一次运行清理）*/
        if (Object.keys(searchObj).length > 0) {
            /*清理条件为空的属性*/
            for (let key in searchObj) {
                if (searchObj[key] === '') delete searchObj[key];
            }
            /*清理后变成空对象*/
            if (Object.keys(searchObj).length === 0) {
                return searchData
            }
        }

        /*递归结束判断*/
        if (Object.keys(searchObj).length === 0) {//当条件的所有参数被消耗，成空对象，则完成尾递归
            return finalData.data
        }

        /*递归参数三的准备*/
        let argumentThree = {};//参数三
        if (finalData.isNotInput === true) {//第三参数不是人为输入
            argumentThree = {...finalData}//继承上一次尾递归的值
        } else {//是人为输入
            argumentThree = {isNotInput: true, data: []}//初始化第一次调用的值
        }

        /*递归参数二的准备*/
        let argumentTwo = {...searchObj};//参数二
        let currentKey, currentValue;//定义本次的键与值
        currentKey = Object.keys(argumentTwo)[0];//获取对象的一个键名
        currentValue = argumentTwo[currentKey];//获取对应的值
        delete argumentTwo[currentKey];//删除本次的属性

        /*递归参数一的准备*/
        let argumentOne = [...searchData];//贮备下一次递归用的参数一
        argumentOne = [...argumentOne.filter(item => item[currentKey] === currentValue)];//筛选符合本次键值的数据
        argumentThree.data = [...argumentOne];//对筛选出来的数据做保存或覆盖，并利用参数携带到下一次递归中去

        /*尾递归*/
        return this.matchArrayData(argumentOne, argumentTwo, argumentThree);
    },
    /*根据传入的属性与属性值，找出参数三中对应的数据*/
    valueMatchKeys(keyValue, keyName, matchData) {
        let finalArrData = [];
        if (Array.isArray(matchData)) {//是数组
            matchData.map(i => {
                if (i instanceof Object) {
                    if (i[keyName] === keyValue) {
                        finalArrData.push(i)
                    }
                }
            })
        }
        return finalArrData;
    },
};
export default {
    ...CheckRule,
    ...OpenBox,
    ...Notice,
    ...Deal,

    ...dealData,
}
